// 定义产品结构体 `Product`，包含三个部分 `part_a`、`part_b`、`part_c`。
struct Product {
    part_a: String,
    part_b: String,
    part_c: String,
}

// 定义生成器结构体 `Builder`，负责构建产品 `Product`。
struct Builder {
    product: Product, // 生成器内部持有一个 `Product` 对象。
}

impl Builder {
    // 构造函数 `new()`，创建一个新的生成器对象。
    fn new() -> Self {
        Self {
            product: Product {
                part_a: String::new(), // 初始化 `Product` 的部分为空字符串。
                part_b: String::new(),
                part_c: String::new(),
            },
        }
    }

    // 构建方法 `build_part_a()`，设置产品的 `part_a` 部分并返回生成器自身的可变引用。
    fn build_part_a(&mut self, part: &str) -> &mut Self {
        self.product.part_a = part.to_string(); // 设置 `part_a` 的值为传入的参数。
        self // 返回生成器自身的可变引用，以支持链式调用。
    }

    // 构建方法 `build_part_b()`，设置产品的 `part_b` 部分并返回生成器自身的可变引用。
    fn build_part_b(&mut self, part: &str) -> &mut Self {
        self.product.part_b = part.to_string(); // 设置 `part_b` 的值为传入的参数。
        self // 返回生成器自身的可变引用，以支持链式调用。
    }

    // 构建方法 `build_part_c()`，设置产品的 `part_c` 部分并返回生成器自身的可变引用。
    fn build_part_c(&mut self, part: &str) -> &mut Self {
        self.product.part_c = part.to_string(); // 设置 `part_c` 的值为传入的参数。
        self // 返回生成器自身的可变引用，以支持链式调用。
    }

    // 构建方法 `build()`，返回构建好的 `Product` 对象的不可变引用。
    fn build(&self) -> &Product {
        &self.product // 返回不可变引用，以获取最终构建好的 `Product` 对象。
    }
}

// 主函数入口 `main()`，演示生成器模式的使用。
pub fn main() {
    let mut builder = Builder::new(); // 创建一个新的生成器对象。
    builder
        .build_part_a("Part A") // 构建 `part_a` 部分。
        .build_part_b("Part B") // 构建 `part_b` 部分。
        .build_part_c("Part C"); // 构建 `part_c` 部分。
    let product = builder.build(); // 构建最终的产品 `Product`。
    println!(
        "Product parts: {}, {}, {}",
        product.part_a,
        product.part_b,
        product.part_c // 打印构建好的产品的各个部分。
    );
}
